﻿package fwk.siteManager2 {
	

	import fwk.text.TextCSS;
	import flash.display.Sprite;
	import flash.display.GradientType;
	import flash.events.MouseEvent;
	import flash.display.MovieClip;
	import flash.display.DisplayObject;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode
	import flash.display.StageQuality;
	import flash.events.Event;
	import flash.display.LoaderInfo;
	import flash.net.getClassByAlias;
	import flash.net.registerClassAlias;
	import flash.text.TextField;
	import fwk.siteManager2.BO.RessourceGroupData;
	import fwk.siteManager2.BO.PageData;
	import fwk.siteManager2.interfaces.IDataManager;
	import fwk.siteManager2.interfaces.IMainBase;
	import fwk.siteManager2.managers.CCodeManager;
	import fwk.siteManager2.managers.TemplatesCacheManager;
	
	import fwk.loaderManager.LoaderItemGroup;
	import fwk.loaderManager.LoaderItemObject;
	import fwk.siteManager2.events.ContainerLoaderEvent;
	import fwk.siteManager2.events.SiteManagerEvent;
	import fwk.siteManager2.events.TemplateEvent;
	import fwk.loaderManager.events.LoaderEvent;
		
	import fwk.siteManager2.interfaces.ITemplate;
	import flash.utils.getDefinitionByName;
	import fwk.debug.DebugDisplayer;
	
	import flash.system.System;
	

	/**
	 * Cette classe représente le Main du site. Vous pourvez pas instancier cette classe directement, votre Main doit hérité de cette classe.
	*/
	public class MainBase extends MovieClip implements IMainBase	{
		
		private static var _instance:Object;
		private var _xmlTemplates:XML;
		private var _xmlContentPage:XML;
		
		private var _width:int;
		private var _height:int;
		
		private var _containerSite:Sprite;
		private var _tabClipToCenter:Array;
		private var _containerPage:Sprite;
		private var _centerPage:Boolean = false;
		
		
		private var _uipageCurrent:String = "";
		private var _deepLinkToLoad:String = "";
		private var _currentPage:Template;
		private var _oldPage:Template;
		private var _templatesCacheManager:TemplatesCacheManager;
		
		private var _deepLink:String = "";
		private var _deepLinkPrevious:String = null;
		
		private var _splitDeepLink:String = "/";
		
		private var _onLoadingPage:Boolean = false;
		
		private var _cCodeManager:CCodeManager;
		
		private var _textDisplayer:TextCSS;
		
		
		private var _crossTransition:Boolean = false;
		private var _debugDisplayer:DebugDisplayer;
		
		private var _spriteDesactivation:Sprite;


		public function get xmlContentPage():XML{
			return _xmlContentPage;
		}
		
		/**
		 * En renseignant une css, les méthodes initTextFromNode et initTextFromString sont utilisables
		 */
		public function set css(cssString:String):void
		{
			//CSS
			_textDisplayer 	= new TextCSS(cssString);
		}
		
		/**
		 * Renvoi le xml templates
		 */
		public function get xmlTemplates():XML{
			return ContainerLoader.getInstance().xmlTemplates;
		}
		/**
		 * Renvoi le xml config
		 */
		public function get xmlConfig():XML{
			return ContainerLoader.getInstance().xmlConfig;
		}
		/**
		 * Renvoi le deepLink demandé pour l'afficher lorsque qu'on arrive sur le site 
		 */
		public function get firstDeepLinkToGo():String{
			return _deepLinkToLoad;
		}
		public function set firstDeepLinkToGo(val:String):void{
			_deepLinkToLoad = val;
		}
		/**
		 * Renvoi le caractère qui sépare les niveaux de deeplink
		 */
		public function get splitDeepLink():String{
			return _splitDeepLink;
		}
		/**
		 * Renvoi le deeplink précédent
		 */
		public function get deepLinkPrevious():String{
			return _deepLinkPrevious;
		}
		/**
		 * Renvoi le ITemplate correspondant à la page actuellement affiché, null si aucun
		 */
		public function get currentPage():ITemplate{
			return _currentPage;
		}
		/**
		 * Renvoi l'instance du MainBase
		 */
		public static function getInstance():Object{
			return _instance;
		}
		/**
		 * Renvoi le clip qui contient les pages
		 */
		public function get containerPage():Sprite{
			return _containerPage;
		}
		/**
		 * Defini le clip qui va contenir les pages. Il n'est pas obligatoire de le définir car un clip est créer automatiquement.
		 */
		public function set containerPage(val:Sprite):void
		{
			if ( _containerPage != null) {
				
				var tabElem:Array = new Array();
				var elem:DisplayObject;
				for (var i:int = 0; i < _containerPage.numChildren; i++) 
				{
					elem = _containerPage.getChildAt(i) as DisplayObject;
					tabElem.push(elem);
				}
				for (i = 0; i < tabElem.length; i++) 
				{
					elem = tabElem[i] as DisplayObject;
					val.addChild(elem);
				}
				
			}
			
			_containerPage = val;
		}
		/**
		 * Renvoi le clip qui contient les pages ainsi que les éléments du site déclaré dans le xml templates dans le noeud structure
		 */
		public function get containerSite():Sprite{
			return _containerSite;
		}
		public function set containerSite(val:Sprite):void
		{
			
			if ( _containerSite != null) {
				
				var tabElem:Array = new Array();
				var elem:DisplayObject;
				for (var i:int = 0; i < _containerSite.numChildren; i++) 
				{
					elem = _containerSite.getChildAt(i) as DisplayObject;
					tabElem.push(elem);
				}
				for (i = 0; i < tabElem.length; i++) 
				{
					elem = tabElem[i] as DisplayObject;
					val.addChild(elem);
				}
			}
			
			_containerSite = val;
		}
		/**
		 * Renvoi le deeplink en cours
		 */
		public function get deepLink():String{
			return _deepLink;
		}
		/**
		 * Set le deeplink, ce qui déclenche l'evenement SiteManagerEvent.CONTEXT_CHANGE sur le MainBase mais ne fait pas appel à loadAndDisplayPage
		 */
		public function set deepLink(val:String):void 
		{
			
			/*if ( val.substr(0, 1) != "/")
			{
				val = "/" + val;
			}
			
			_deepLink = val;
			// déclenchement evenement context change
			var evt:SiteManagerEvent = new SiteManagerEvent(SiteManagerEvent.CONTEXT_CHANGE);
			evt.deepLink = _deepLink;
			_instance.dispatchEvent(evt);*/
			
			loadAndDisplayPage(val);
		}
		/**
		 * Renvoi la largeur minimum du site, cette propriété est renseigné dans xml config
		 */
		public function get siteWidth():int{
			return _width;
		}
		/**
		 * Renvoi la hauteur minimum du site, cette propriété est renseigné dans le xml config
		 */
		public function get siteHeight():int{
			return _height;
		}
		/**
		 * Renvoi le repertoire pays, c'est soit la valeur renseigné dans le xml config du site, soit celle renseigné en flashvars si celle ci est renseigné
		 */
		public function get countryPath():String{
			return ContainerLoader.getInstance().countryPath;
		}
		/**
		 * Renvoi le repertoire communs, c'est soit la valeur renseigné dans le xml config du site, soit celle renseigné en flashvars si celle ci est renseigné
		 */
		public function get sharedPath():String{
			return ContainerLoader.getInstance().sharedPath;
		}
		/**
		 * Renvoi le clip "Mére" de tout le site qui s'occupe de charger tout. C'est lui aussi qui recoit les flashvars.
		 */
		public function get containerLoader():MovieClip{
			return ContainerLoader.getInstance();
		}
		
		
		public function MainBase():void 
		{
			
			
		}
		public function init(classSup:Object = null):void 
		{
			
			if (_instance != null) {
				debugIt("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
				debugIt("--------------------------------------------------");
				debugIt("ATTENTION !!!!!  Tentative d'instanciation de la classe Main. la classe Main doit être instancier qu'une fois pour le projet ! ");
				debugIt("--------------------------------------------------");
				debugIt("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
			}else {
	
				App.mainClass = this;
				_instance = this;
				
				
				//tempalte cache manager
				_templatesCacheManager = new TemplatesCacheManager();
		
				//register classes
				//registerClassAlias("TemplateModuleManager", TemplateModuleManager );
				///////////////////////////////////////////////////////
				
				addEventListener(SiteManagerEvent.ON_READY, onReady);
				ContainerLoader.getInstance().addEventListener(ContainerLoaderEvent.RESSOURCES_LOADED, _init);
				
			}
			

		}
		
		private function _init(evt:ContainerLoaderEvent):void 
		{
			/*debugIt("");
			debugIt("");
			debugIt("-------------------------------------------");
			debugIt("Init main");
			debugIt("-------------------------------------------");*/
			
			ContainerLoader.getInstance().removeEventListener(ContainerLoaderEvent.RESSOURCES_LOADED, _init);
			
			// ajout du main au conteneur principal
			ContainerLoader.getInstance().stage.addChild(_instance as MovieClip);
			

			// code manager
			_cCodeManager = new CCodeManager( _instance);
			
			
			// init variables
			_xmlTemplates 	= ContainerLoader.getInstance().xmlTemplates;
			_splitDeepLink 	= ContainerLoader.getInstance().splitDeepLink;
			if (ContainerLoader.getInstance().xmlContentPage != null) _xmlContentPage = ContainerLoader.getInstance().xmlContentPage;
			
			// events
			ContainerLoader.getInstance().addEventListener(ContainerLoaderEvent.SWFADRESS_CHANGE, onSwfAdressChange);
			ContainerLoader.getInstance().addEventListener(ContainerLoaderEvent.RESSOURCES_PAGE_LOADED, onPageRessourceCompleted);
			ContainerLoader.getInstance().addEventListener(ContainerLoaderEvent.ERROR_LOAD, onErrorLoadPage);
			ContainerLoader.getInstance().addEventListener(ContainerLoaderEvent.FULL_LOADED, onFullLoaded);
			_instance.addEventListener(SiteManagerEvent.CONTEXT_CHANGE, onContextChange);
			
			
			//init de la structure du sites
			initStructure();
			


			
			//debug displayer
			if (ContainerLoader.getInstance().debugMode) {
				_debugDisplayer = new DebugDisplayer(ContainerLoader.getInstance().stage);
			}
			
			
			// page par défaut à afficher
			if (ContainerLoader.getInstance().deepLinkToLoad != null && ContainerLoader.getInstance().deepLinkToLoad != "")
			{
				_deepLinkToLoad = ContainerLoader.getInstance().deepLinkToLoad;
			}
			
			// declanchement evenement indiquant que la main est pret
			_instance.dispatchEvent(new SiteManagerEvent(SiteManagerEvent.ON_READY));
			
			
			
		}
		
		private function onFullLoaded(e:ContainerLoaderEvent):void 
		{
			_instance.dispatchEvent(new SiteManagerEvent(SiteManagerEvent.FULL_LOADED));
		}
		
		/**
		 * Methode appelé automatiquement dés qu'il y a un changement de deepLink
		 * @param	evt
		 */
		public function onContextChange(evt:SiteManagerEvent):void
		{
			setSwfAdrress(_deepLink);
		}
		/**
		 * Methode appelé automatiquement dés que les ressources globales sont toutes chargées et que l'application est prète
		 * @param	evt
		 */
		public function onReady(evt:SiteManagerEvent):void
		{

		}
		private function initStructure():void
		{

			
			// sprite desactivation
			_spriteDesactivation = new Sprite();
			_spriteDesactivation.alpha = 0;
			_spriteDesactivation.graphics.beginFill(0xff0000, 1);
			_spriteDesactivation.graphics.drawRect(0, 0, 50, 50);
			
			//creation conteneur du site
			if(_containerSite == null){
				_containerSite = new Sprite();
				_instance.stage.addChild(_containerSite);
			}
			
			//center content
			_tabClipToCenter = new Array();
			
			//taille contenu
			_width = parseInt(xmlConfig.scene.@width);
			_height = parseInt(xmlConfig.scene.@height)
			
			//alignement
			// stage setup for resizing
			_instance.stage.addEventListener(Event.RESIZE, onResize);
			
			
			// init structure
			//debugIt("--> initStructure");
			if ( _xmlTemplates.structure[0] is XML)
			{
				for (var i:int = _xmlTemplates.structure.children().length()-1; i >= 0; i--)
				{
					var nodeRessource:XML = _xmlTemplates.structure.children()[i];
					var name:String = nodeRessource.name();
					var nodeClip:XML;
					
					switch(name)
					{
						case "clip":
							var obj:Object =  ContainerLoader.getInstance().getloaderItemStructure(nodeRessource.@id).content;
							//debugIt("clip obj " + obj);
							if(nodeRessource.@x != undefined)
								obj.x = parseInt(nodeRessource.@x);
							if(nodeRessource.@y != undefined)
								obj.y = parseInt(nodeRessource.@y);
							if (nodeRessource.@center[0] != "false") {
								_tabClipToCenter.push(obj as DisplayObject);
							}
							_containerSite.addChild(obj as DisplayObject);
							
						break;
						case "containerPage":
							if(_containerPage == null){
								_containerPage = new Sprite();
								_containerSite.addChild(_containerPage as Sprite);
							}
						break;
					}
				}
			}
			
			if (_containerPage == null)
			{
				_containerPage = new Sprite();
				_containerSite.addChild(_containerPage as Sprite);
			}
			
			
			_instance.resize();
			
		}
		
		private function onResize(evt:Event):void
		{
			_instance.resize();
		}
		
		private function resize():void
		{

			if (stage.align == StageAlign.TOP_LEFT) {
				for (var i:int = 0; i < _tabClipToCenter.length; i++)
				{
					
					centerClip(_tabClipToCenter[i] as DisplayObject);
				}
				
				if (_centerPage)
				{
					if(_currentPage != null) centerClip(_currentPage as DisplayObject);
				}
				
				
				// sprite desactivation toute action sur le site
				_spriteDesactivation.width = stage.stageWidth+10;
				_spriteDesactivation.height = stage.stageHeight+10;
				
			}
			


		}
		
		private function centerClip(clip:DisplayObject):void 
		{
			if(_instance.stage.stageWidth >= _width)
				clip.x = Math.floor(_instance.stage.stageWidth/2 -_width/2);
			else
				clip.x = 0;
			
			if(_instance.stage.stageHeight >= _height)
				clip.y = Math.floor(_instance.stage.stageHeight/2 - _height/2);
			else
				clip.y = 0;
		}
		/*public function onDeepLinkChange(evt:ContainerLoaderEvent)
		{
			_deepLink = evt.deepLink;
		}*/
		
		//----------------------------------------------------------------------
		//----------------------------------------------------------------------
		//----- Gestion switch des pages
		//----------------------------------------------------------------------
		//----------------------------------------------------------------------
		
		
		/**
		 * Ferme la page qui est cours d'affichage, si aucune page ne fait rien
		 */
		public function closePage():void 
		{	
			if (_currentPage != null)
			{
				_crossTransition = false;
				_oldPage = _currentPage;
				_currentPage = null;
				removeOldPage();
			}

		}
		/**
		 * Charge et affiche la page correspondant a la chaine deeplink passer en paramètre si elle existe et est décalré dans le xml templates dans le noeud pages
		 * @param	idChaine : Soit un id de page soit une chaine deeplink avec comme premier niveau un id de page
		 * @param	crossTransition : true si l'animation de fermeture de la apge en cours doit se faire en même temps que l'anim d'ouverture de la page à afficher
		 */
		public function loadAndDisplayPage(idChaine:String, crossTransition:Boolean = false):void
		{		
			
			if ( !_onLoadingPage)
			{
			
				var idPage:String = idChaine;
				var tabCh:Array = idPage.split(_splitDeepLink);

				if (idChaine.substring(0, 1) != "/") {
					idChaine = "/" + idChaine;
				}
				if (tabCh != null && tabCh.length > 1) idPage = tabCh[1];
				

				// true si la transition close de la page actuelle se fait en même temps que la transition display de la prochaine page, sinon elle s'enchaine sans se chevaucher.
				_crossTransition = crossTransition;
				
				
				if (idPage != _uipageCurrent)
				{
					_xmlContentPage = null;
					_onLoadingPage = true;				
					_deepLinkToLoad = idChaine;
					
					//debugIt("load page " + _deepLinkToLoad);
					ContainerLoader.getInstance().loadPage(_deepLinkToLoad);
					
				/*}else if (idPage == _uipageCurrent)
				{
					if (_deepLink != "" && idChaine != _deepLink) _deepLinkPrevious = _deepLink;
					_deepLink = idChaine;
					// déclenchement evenement context change
					var evt:SiteManagerEvent = new SiteManagerEvent(SiteManagerEvent.CONTEXT_CHANGE);
					evt.deepLink = deepLink;
					_instance.dispatchEvent(evt);
					
					*/
				}else if (_deepLink != idChaine)
				{
						_deepLinkPrevious = _deepLink;
						_deepLink = idChaine;
						// déclenchement evenement context change
						var evt:SiteManagerEvent = new SiteManagerEvent(SiteManagerEvent.CONTEXT_CHANGE);
						evt.deepLink = deepLink;
						_instance.dispatchEvent(evt);
				}
				
			
			}
			
			
			
		}

		private function onPageRessourceCompleted(evt:ContainerLoaderEvent):void 
		{
			startDisplayPage(evt.deepLink);
		}

		private function startDisplayPage(deeplink:String):void 
		{
			// recup id page
			var idPage:String = deeplink;
			var tabCh:Array = idPage.split(_splitDeepLink);
			if (tabCh != null && tabCh.length > 1) idPage = tabCh[1];
			
			_uipageCurrent = idPage;
			
			displayPage(_uipageCurrent);
		}
		private function onErrorLoadPage(evt:Event):void 
		{
			_onLoadingPage = false;
			var dl:String = _deepLinkToLoad;
			_deepLinkToLoad = null;

			// déclenchement evenement context change
			var ev:SiteManagerEvent = new SiteManagerEvent(SiteManagerEvent.CONTEXT_CHANGE);
			ev.deepLink = dl;
			_instance.dispatchEvent(ev);
			

			
		}
		private function displayPage(id:String):void 
		{



			_oldPage = _currentPage;
			
			if (_crossTransition)
			{
				initCurrentPage();
				if (_oldPage != null)
				{
					removeOldPage();
				}else {
					_onLoadingPage = false;
					dispatchEvent(new TemplateEvent(TemplateEvent.ON_READY));
				}
				
			}else {
				if (_oldPage != null)
				{
					removeOldPage();
				}
				else
				{
					initCurrentPage();
					_onLoadingPage = false;
					dispatchEvent(new TemplateEvent(TemplateEvent.ON_READY));
				}
			}
			
			

			
		}
		//----------------------------------------------------------------------
		private function removeOldPage():void 
		{
			_oldPage.close();
		}

		//----------------------------------------------------------------------
		private function onClosePage(event:Event):void 
		{
			var page:Template = event.currentTarget as Template;
			
			page.removeEventListener(TemplateEvent.CLOSED, onClosePage);
			page.parent.removeChild(page);
			page.dispose();
			
			dispatchEvent(new TemplateEvent(TemplateEvent.CLOSED));	
			
			if (!_crossTransition)
			{
				_centerPage 	= false;
				_currentPage 	= null;
				_oldPage 		= null;
				
				
				if (_deepLinkToLoad != null)
				{
					initCurrentPage();
					_onLoadingPage = false;
					dispatchEvent(new TemplateEvent(TemplateEvent.ON_READY));
				}else
				{
					_onLoadingPage = false;
					// déclenchement evenement context change
					var evt:SiteManagerEvent = new SiteManagerEvent(SiteManagerEvent.CONTEXT_CHANGE);
					evt.deepLink = deepLink;
					_instance.dispatchEvent(evt);
					
				}
			}else {
				_oldPage 			= null;
				_onLoadingPage = false;
				dispatchEvent(new TemplateEvent(TemplateEvent.ON_READY));
			}

			try{
				// test garbage collector
				//System.gc();
				//trace("System.gc();");
			}catch (e:Error)
			{
				
			}
			
		}
		//----------------------------------------------------------------------
		private function initCurrentPage():void 
		{
			
				_deepLinkPrevious = deepLink;	
				
				 // set du deeplink
				_deepLink = _deepLinkToLoad;
				_deepLinkToLoad = null;
				
				_currentPage	 	= null;
				
				//récup page du cache
				_currentPage = _templatesCacheManager.getItem(_uipageCurrent) as Template;
				
				var initPage:Boolean = false;
				if(_currentPage == null){
				
					var pageData:PageData;
					var ressourceGroupDate:RessourceGroupData;

					/*_xmlContentPage = ContainerLoader.getInstance().xmlContentPage;

					if (_xmlContentPage != null) {
						pageData = new PageData();
						pageData.init(_xmlContentPage.children()[0]);
						pageData.className = "TemplateModuleManager";
					}else {
						pageData =  dataManager.getPageData(_uipageCurrent);
					}*/
					
					pageData =  dataManager.getPageData(_uipageCurrent);

					//debugIt("XXX Error creattion class templates " + className);
					//debugIt("--> instance de Template générique");
					_currentPage = new Template();
					//throw e;

					if (pageData.uiRessource != null && pageData.uiRessource != "")
					{
						ressourceGroupDate = dataManager.getRessourceGroupData(pageData.uiRessource);
					}
					
					//trace("pageData " + pageData);
					//trace("ressourceGroupDate " + ressourceGroupDate);
					
					if(ressourceGroupDate != null) _currentPage.ressourceGroupDate = ressourceGroupDate;
					_currentPage.pageData = pageData;
					_containerPage.addChild(_currentPage);
					_currentPage.uipage = pageData.id;
					
					initPage = true;
					
					// on met en cache
					var loaderITemPage:LoaderItemGroup = getLoaderItemPage(pageData.id);
					if (loaderITemPage != null &&  getLoaderItemPage(pageData.id).cache)
					{
						//trace("on met en cache la page " + pageData.id);
						_currentPage.cache = true;
					   _templatesCacheManager.addItemStatic(_currentPage.uipage, _currentPage);
					}


				}else {
					_containerPage.addChild(_currentPage);	
				}
				
				// ecouteur close page
				_currentPage.addEventListener(TemplateEvent.CLOSED, onClosePage);
				
				 
				// déclenchement evenement context change
				var evt:SiteManagerEvent = new SiteManagerEvent(SiteManagerEvent.CONTEXT_CHANGE);
				evt.deepLink = deepLink;
				_instance.dispatchEvent(evt);
				
				 // init page
				if( initPage) _currentPage._init();

				 // display page
				 _currentPage._display();
				 
				_centerPage = _currentPage.pageData.center;
				 resize();
				 
				 // on vide le cache temporaire
				 ContainerLoader.getInstance().ressourcesManager.clearItemsPriority();




		}
		
		
		
		//----------------------------------------------------------------------
		//	SwfAdress change
		//----------------------------------------------------------------------
		/**
		 * Change la chaine affiché dans la barre d'adresse du navigateur après le #
		 * @param	chaine : Chaine a afficher dans la barre d'adresse
		 * @param	title : Chaine à afficher dans barre de titre du navigateur
		 */
		public function setSwfAdrress(chaine:String, title:String = ""):void 
		{
			//debugIt("MainBase setSwfAdrress " +  chaine);
			ContainerLoader.getInstance().setSwfAdrress(chaine, title);
		}
		/**
		 * Change le titre affiché en haut du navigateur
		 * @param	title : Chaine à afficher dans barre de titre du navigateur
		 */
		public function setSwfAdrressTitle(title:String):void 
		{
			
			//traitement chaine, on retire les balise html éventuelles
			var textfield:TextField	= new TextField();
			textfield.htmlText = title;

			
			ContainerLoader.getInstance().setSwfAdrressTitle(textfield.text);
		}
		/**
		 * Force le navigateur à faire un back navigateur
		 */
		public function setPreviousSwfAdress():void
		{
			ContainerLoader.getInstance().setPreviousSwfAdress();
		}
		
		/**
		 * Renoive la chaine qui est actuellement affiché dans la barre d'adresse du navigateur (chaine après le #) 
		 * @param	title : Chaine à afficher dans la barre de titre du navigateur
		 */
		public function getSwfAdress():String
		{
			return ContainerLoader.getInstance().getSwfAdress();
		}
		
		private function onSwfAdressChange(evt:ContainerLoaderEvent):void 
		{
			//debugIt("onSwfAdressChange " +  evt.deepLink);
			
			// déclenchement evenement context change
			var evt2:ContainerLoaderEvent = new ContainerLoaderEvent(ContainerLoaderEvent.SWFADRESS_CHANGE);
			evt2.deepLink = evt.deepLink;
			_instance.dispatchEvent(evt2);
			
			if (evt.deepLink != null && evt.deepLink  != _deepLink) loadAndDisplayPage(evt.deepLink);

		}
		
		//----------------------------------------------------------------------
		//	Debug
		//----------------------------------------------------------------------
		/**
		 * Equivalent au trace de flash, mais qui en plus trace sur Alcon (module air) et dans le debuggeur interne à MainBase
		 * @param	str : chaine à tracé
		 * @param	tmpNum
		 */
		public function debugIt(str:Object, tmpNum:Number = 1):void 
		{
			if( _debugDisplayer != null) _debugDisplayer.trace(str);
			ContainerLoader.getInstance().debugIt(str,tmpNum);
		}
		//----------------------------------------------------------------------
		//	Recup ressources
		//----------------------------------------------------------------------
		/**
		 * Renvoie l'object chargé correspondant à l'id de la ressources déclaré dans le xml config que l'on veux récupéré
		 * @param	id : Correspond à l'id renseigné dans le xml config dans le noeud ressourcesGlobal
		 * @return Un object qui rreprésente la ressources qui a été chargé. Si c'est un swf, il faut la typer MovieClip, si c'est un xml, à typer String, etc...
		 */
		public function getRessourceGlobal(id:String):Object
		{
			if (ContainerLoader.getInstance().getloaderItemRessourceGlobal(id) != null) {
				return ContainerLoader.getInstance().getloaderItemRessourceGlobal(id).content;
			}else
			{
				return null;
			}

		}
		/**
		 * Renvoie un LoaderItemGroup (voir fwk.loaderManager.LoaderItemGroup) correspondant à un groupe de ressources à chargé pour un id de page donné (déclaré dans le noeud pages du xml templates).
		 * @param	id : id de la page dont on veux obtenir le LoaderItemGroup
		 * @return  LoaderItemGroup : Object de chargement géré par le LoaderManager (voir fwk.loaderManager.LoaderManager)
		 */
		public function getLoaderItemPage(id:String):LoaderItemGroup
		{
			
			return ContainerLoader.getInstance().getLoaderItemPage(id);

		}

		/**
		 * Renvoie un LoaderItemGroup (voir fwk.loaderManager.LoaderItemGroup) correspondant à un groupe de ressources à chargé pour un id de ressource donné (déclaré dans le noeud ressources du xml templates).
		 * @param	id : id de la ressources dont on veux obtenir le LoaderItemGroup
		 * @return  LoaderItemGroup : Object de chargement géré par le LoaderManager (voir fwk.loaderManager.LoaderManager)
		 */
		public function getLoaderItemRessource(id:String):LoaderItemGroup
		{

			return ContainerLoader.getInstance().getLoaderItemRessource(id);
			
		}

		/**
		 * Renvoie le clip correspondant à l'id renseigné dans le xml temapltes dans le noeud structure
		 * @param	id
		 * @return
		 */
		public function getClipStructure(id:String):Object
		{
			return ContainerLoader.getInstance().getloaderItemStructure(id).content;
		}
		public function get dataManager():IDataManager
		{
			return ContainerLoader.getInstance().dataManager as IDataManager;
		}
		
		
		//--------------------------------------------------------
		//--- desactivation/activation interaction sur le site
		/**
		 * Si à false desactive les actions sur le site
		 */
		public function set interactionOn(val:Boolean):void
		{
			
			if ( !val)
			{
				stage.addChild(_spriteDesactivation);
			}else {
				if(_spriteDesactivation.parent != null)
				stage.removeChild(_spriteDesactivation);
			}
			

		}
		
		//----------------------------------------------------------------------
		//	loadRessource indépendante
		//----------------------------------------------------------------------
		/**
		 * Force le chargement d'un goupe de ressource déclaré dans le xml templates
		 * @param	obj : Soit l'id de la ressource à charger (id présent dans le xml templates), soit le LoaderItemGroup correspondant à un groupe de ressources déclaré dans le xml templates dans le noeud ressources, pages ou templates
		 * @return Renvoie le LoaderItemGroup correspondant au groupe de ressources à charger
		 */
		public function loadGroupRessource(obj:Object):LoaderItemGroup
		{
			return ContainerLoader.getInstance().loadGroupRessource(obj);
			
		}
		//----------------------------------------------------------------------
		//	Load all in Background et cache
		//----------------------------------------------------------------------
		/**
		 * Ajoute un groupe de ressources correspondant à l'id dans la pile de chargement en background du site
		 * @param	id : Identifiant de la ressource à charger (id présent dans le xml templates)
		 */
		public function addInBackgroundLoading(id:String):void
		{
			ContainerLoader.getInstance().addInBackgroundLoading(id);
			
		}
		/**
		 * Déclare en tant que ressources static un groupe de ressources correspondant à l'id. Cela a pour effet de ne pas recharger à chaque fois la ressource en la gardant en cache.
		 * @param	id : Identifiant de la ressource à charger (id présent dans le xml templates)
		 */
		public function addToCacheStatic(id:String):void
		{
			ContainerLoader.getInstance().addToCacheStatic(id);
			
		}
		/**
		 * Lance le chargemebnt des groupes de ressources présent dans la pile de chargement en background du site
		 */
		public function startBackgoundLoading():void
		{
			ContainerLoader.getInstance().startBackgoundLoading();
		}
		
		//----------------------------------------------------------------------
		//	TEXTE
		//----------------------------------------------------------------------
		/**
		 * Cette méthode nécéssite l'utilisation d'une CSS. Il faut renseigné la propriété css de MainBase pour pouvoir utiliser cette méthode.
		 * Initialise un champ texte à partir d'un noeud xml formatté. Le noeud doit être de la forme <node style=".monStyleCss"><![CDATA[MonTexte]]></node>.
		 * @param	mcT : Clip MovieClip contenant un champs text (TextField) nommé tTexte obligatoirement
		 * @param	node : Type XML. Le noeud doit être de la forme <node style=".monStyleCss"><![CDATA[MonTexte]]></node>.
		 * @param	scopeFunction : Référence à un classe qui va recevoir les appel de fonctions event présent dans le champs text. Par exemple <node style=".monStyleCss"><![CDATA[<a href='event:fonction1'>MonTexte</a>]]></node> executera la méthode se nommant "fonction1" sur la référence scopeFunction .
		 */
		public function initTextFromNode(mcT:MovieClip, node:XML, scopeFunction:Object = null):void
		{
			if( _textDisplayer != null) _textDisplayer.initTextFromNode(mcT, node, scopeFunction);
		}
		/**
		 * Cette méthode nécéssite l'utilisation d'une CSS. Il faut renseigné la propriété css de MainBase pour pouvoir utiliser cette méthode.
		 * Initialise un champ texte à partir d'un texte (String) et un nom de style CSS.
		 * @param	mcT : Clip MovieClip contenant un champs text (TextField) nommé tTexte obligatoirement
		 * @param	text : String à mettre dans le champs texte
		 * @param	className : Un nom du style présent dans la CSS. Il faut mettre le "." devant le nom (ex : ".labelTitle" )
		 * @param	scopeFunction : Référence à un classe qui va recevoir les appel de fonctions event présent dans le champs text. Par exemple <node style=".monStyleCss"><![CDATA[<a href='event:fonction1'>MonTexte</a>]]></node> executera la méthode se nommant "fonction1" sur la référence scopeFunction .
		 */
		public function initTextFromString(mcT:MovieClip, text:String, className:String, scopeFunction:Object = null, fontSizeOffset:Number = 0):void
		{
			if( _textDisplayer != null) _textDisplayer.initTextFromString(mcT, text, className, scopeFunction, fontSizeOffset);
		}
		public function get textDisplayer():TextCSS { return _textDisplayer; }
		

		//----------------------------------------------------------------------
		//	code
		//----------------------------------------------------------------------
		public function startCode1(colorParticule:Number = 0xffffff):void 
		{
			
			try {
				
				var container:Sprite = new Sprite();

				for(var i:int = 0; i< 15; i++){
					
					var clip:Sprite = new Sprite();
					clip.graphics.beginFill(0xffffff, 1); //1/(i+1));
					clip.graphics.drawCircle(0,0,3);
					container.addChild(clip);
					
					if(i!=0){
						clip.alpha = 0;
					}
					
				}
				containerLoader.stage.addChild( container);

				containerLoader.stage.addEventListener(Event.ENTER_FRAME, onEnter);


				function onEnter(evt:Event):void
				{
					container.graphics.clear();
					
					
					
					
					var clipPrevious:Sprite;
					for(var i:int = 0; i< container.numChildren; i++)
					{
						var clip:Sprite = container.getChildAt(i) as Sprite;
						
						container.graphics.lineStyle(1, 0xffffff, 1/(i+1));
						if( i ==0){
							container.graphics.moveTo(clip.x, clip.y);
							deplace(clip, stage.mouseX, stage.mouseY, 10);
						}else{
							deplace(clip, clipPrevious.x, clipPrevious.y,  2);
							container.graphics.lineTo(clip.x, clip.y);
						}
						clipPrevious = clip;
						
						
						
						
					}

					container.graphics.endFill();

					
				}


				function deplace(mc:Sprite, px:Number, py:Number,  constant:int):void
				{
					
					mc.x += (px - mc.x)/constant;
					mc.y += (py - mc.y)/constant;
					
				}
				
				
			}catch (e:Error) {
				
			}
			


			
		}
		public function startCode2():void 
		{
			if (_debugDisplayer == null) {
				
				_debugDisplayer = new DebugDisplayer(ContainerLoader.getInstance().stage);
				containerLoader.debugMode = true;

			}
			
		}

	}
}